package com.sumainfor.pc.market.service;
import com.alibaba.fastjson.JSON;
import com.qiniu.util.Json;
import com.sumainfor.common.Constants;
import com.sumainfor.common.entity.ParentDeptVo;
import com.sumainfor.common.entity.SysUserVo;
import com.sumainfor.common.util.*;
import com.sumainfor.common.utlis.ComUtils;
import com.sumainfor.common.utlis.ParamsCommon;
import com.sumainfor.pc.market.dao.RdTenantMapper;
import com.sumainfor.pc.market.dao.RdWorderInfoMapper;
import com.sumainfor.pc.market.dao.RdWorderMapper;
import com.sumainfor.pc.market.dao.UtilsMapper;
import com.sumainfor.pc.market.feign.Zfeign.ZwxTenantFeign;
import com.sumainfor.pc.market.feign.Zfeign.ZzuulFeign;
import org.apache.commons.collections.MapUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Date 2018年11月7日
 * @Describe 工程部查询房源配置
 */
@Service
public class RdWorderService implements Serializable {

    private ReentrantLock lock = new ReentrantLock(false);

    Logger log = LoggerFactory.getLogger(RdWorderService.class);// 日志

    @Autowired
    private RdWorderMapper rdWorderMapper;
    @Autowired
    private RdTenantMapper rdTenantMapper;
    @Autowired
    private RdWorderInfoMapper rdWorderInfoMapper;
    @Autowired
    private ZwxTenantFeign zwxTenantFeign;
    @Autowired
    private UtilsMapper utilsMapper;
    @Autowired
    private ZzuulFeign zzuulFeign;
    String UUID=null;
    /**
     * @return result
     * @Author
     * @Date 2018年11月7日
     * @Describe 查询今天需带看的所有工单
     */
    public List<Map<String,Object>> getWorderListToday(Map<String,Object> params) {
        return rdWorderMapper.getWorderListToday(params);

    }
    /**
     * 查询今天需带看的所有工单总数
     * @param params
     * @return
     */
    public Integer getWorderListCountToday(Map<String,Object> params){
        return rdWorderMapper.getWorderListCountToday(params);
    }
    /**
     * @Describe 查询未来需带看工单
     */
    public List<Map<String,Object>> getWorderListFuture(Map<String,Object> params) {
        return rdWorderMapper.getWorderListFuture(params);
    }
    /**
     * 查询未来需带看工单总数
     * @param params
     * @return
     */
    public Integer getWorderListCountFuture(Map<String,Object> params){
        return rdWorderMapper.getWorderListCountFuture(params);
    }

    /**
     * @return result
     * @Author
     * @Date 2018年11月7日
     * @Describe 查询公共转单池的列表
     */
    public List<Map<String,Object>> getWorderListPublic(Map<String,Object> params) {
        List<Map<String,Object>> list=rdWorderMapper.getWorderListPublic(params);
        if (list.size()>0) {
            //保存转单人的编号
            List<String> OperIdList = new ArrayList<String>();
            for (Map<String, Object> map : list) {
                if (map.get("OperId") != null && !map.get("OperId").equals("")) {
                    //根据 HouId查询房源信息
                    OperIdList.add(map.get("OperId").toString());
                }
            }
            params.put("houIdList", OperIdList);
            System.out.println("houIdList:"+OperIdList);
            //根据编号去网关查询信息
            JsonResult result = zzuulFeign.getPuserListById(params);
            List<Map<String, Object>> zuulList = (List<Map<String, Object>>)result.get("result");
            if (result.get("errorCode").equals("0")) {
                for (Map<String, Object> map : list) {
                    for (Map<String, Object> map2 : zuulList) {
                        if (MapUtils.getString(map, "OperId").equals(MapUtils.getString(map2, "user_id"))) {
                            map.putAll(map2);
                        }
                    }
                }
            }
        }
        return list;
    }
    /**
     * 查询公共转单池的总数
     * @param params
     * @return
     */
    public Integer getWorderListCountPublic(Map<String,Object> params){
        return rdWorderMapper.getWorderListCountPublic(params);
    }
    /**
     * @Describe 查询私有转单池的列表
     */
    public List<Map<String,Object>> getWorderListPrivate(Map<String,Object> params) {
        List<Map<String,Object>> list=rdWorderMapper.getWorderListPrivate(params);
        if (list.size()>0) {
            //保存转单人的编号
            List<String> OperIdList = new ArrayList<String>();
            for (Map<String, Object> map : list) {
                if (map.get("OperId") != null && !map.get("OperId").equals("")) {
                    //根据 HouId查询房源信息
                    OperIdList.add(map.get("OperId").toString());
                }
            }
            params.put("houIdList", OperIdList);
            System.out.println("houIdList:"+OperIdList);
            //根据编号去网关查询信息
            JsonResult result = zzuulFeign.getPuserListById(params);
            List<Map<String, Object>> zuulList = (List<Map<String, Object>>)result.get("result");
            if (result.get("errorCode").equals("0")) {
                for (Map<String, Object> map : list) {
                    for (Map<String, Object> map2 : zuulList) {
                        if (MapUtils.getString(map, "OperId").equals(MapUtils.getString(map2, "user_id"))) {
                            map.putAll(map2);
                        }
                    }
                }
            }
        }
        return list;
    }
    /**
     * 查询私有转单池的总数
     * @param params
     * @return
     */
    public Integer getWorderListCountPrivate(Map<String,Object> params){

        return rdWorderMapper.getWorderListCountPrivate(params);
    }
    /**
     * @Describe 查询本月已带看工单
     */
    public List<Map<String,Object>> getWorderListAlready(Map<String,Object> params) {
        return rdWorderMapper.getWorderListAlready(params);
    }
    /**
     *查询已带看工单总数
     * @param params
     * @return
     */
    public Integer getWorderListCountAlready(Map<String,Object> params){
        return rdWorderMapper.getWorderListCountAlready(params);
    }
    /**
     * @Describe 查询租客维护
     */
    public List<Map<String,Object>> getWorderListMaintain(Map<String,Object> params) {
        return rdWorderMapper.getWorderListMaintain(params);
    }
    /**
     *查询租客维护总数
     * @param params
     * @return
     */
    public Integer getWorderListCountMaintain(Map<String,Object> params){
        return rdWorderMapper.getWorderListCountMaintain(params);
    }
    /**
     * @Describe 查询换房申请
     */
    public List<Map<String,Object>> getWorderListApply(Map<String,Object> params) {
        return rdWorderMapper.getWorderListApply(params);
    }
    /**
     *查询换房申请总数
     * @param params
     * @return
     */
    public Integer getWorderListCountApply(Map<String,Object> params){
        return rdWorderMapper.getWorderListCountApply(params);
    }
    /**
     * 创建工单 工单状态是租客维护的时候
     *
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult addWorderMaintain(Map<String, Object> params) {
        JsonResult result=new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try{
            try {
                SysUserVo userVo = ContextUtils.getSysUser();
                ParentDeptVo vo = null;
                for (int i = 0; i < userVo.getLength(); i++) {
                    ParentDeptVo vo1 = userVo.getParentDeptVo();
                    if (vo1.getType().equals(3)) {
                        vo = vo1;
                        break;
                    }
                }
                //组装修改工单的数据
                Map<String,Object> map=(Map<String,Object>)params.get("data");
                System.out.println("前端传递的参数:"+params);
                map.put("by", ContextUtils.getUserId());//操作人
                map.put("SetId",ContextUtils.getUserId());// 创建工单的人的编号
                if (vo!=null){
                    map.put("SeId",vo.getDeptId());//接单 操作该工单人的服务中心编号
                }
                map.put("State",0);//工单状态（0 需带看 1带看中 2 带看完成 3 租客维护 4 换房申请）
                map.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                map.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonInsertParms(map);
                if(map!=null){
                    Integer count=rdWorderInfoMapper.updateWorderInfo(map);
                    if (count>0){
                        result.putSuccess("操作成功");
                    }else{
                        result.putFailed("服务器繁忙");
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }
                }else{
                    result.putFailed("服务器繁忙");
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }
    /**
     * 创建工单 第一次创建工单的时候
     *
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult addWorder(Map<String, Object> params) {
        JsonResult result=new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try{
            try {
                SysUserVo userVo = ContextUtils.getSysUser();
                ParentDeptVo vo = null;
                for (int i = 0; i < userVo.getLength(); i++) {
                    ParentDeptVo vo1 = userVo.getParentDeptVo();
                    if (vo1.getType().equals(3)) {
                        vo = vo1;
                        break;
                    }
                }

                //客户编号
                Map<String,Object>uuid2=utilsMapper.getUUID(new HashMap<String,Object>(){{
                    put("uuid", "TenId");
                    put("database", Constants.DATA_SOURCE_TCMKT);
                    put("surface", "tcmkt_tenant");
                }});
                if(uuid2!=null){
                    int number=Integer.valueOf(uuid2.get("uuid").toString());
                    UUID= ComUtils.getLocalTrmSeqNum("te",number);
                }else{
                    UUID=ComUtils.getLocalTrmSeqNum("te",0);
                }
                Map<String,Object> map=(Map<String,Object>)params.get("data");
                boolean ifTenant=false;//租客端是否存在该手机号的记录
                if (map.get("TenMode")==null){
                    return result.putFailed("参数不正确");
                }
                Integer tenCount=rdTenantMapper.getTenantForPactByTenMode(map);//查询后台是否已经创建过租客

                params.put("Phone",map.get("TenMode"));
                params.put("SysId",UUID);
                System.out.println("创建工单发送到我租客端的参数:"+params);
                JsonResult zwxResult=zwxTenantFeign.getTctenForTcmkt(params);
                //查询租客端的信息
                if (zwxResult.get("errorCode").toString().equals("0")){
                    Map<String, Object>  zwxMap=(Map<String,Object>)zwxResult.get("result");
                    System.out.println("查询到租客端的数据:"+zwxMap);
                    if (zwxMap!=null){//如果查询到就用租客端的客户编号
                        map.put("TenId",zwxMap.get("SysId"));
                        ifTenant=true;
                    }else{//如果查询不到就用市场部的 客户 编号
                        map.put("TenId",UUID);
                    }
                    System.out.println("zwxMAP"+zwxMap);
                }
                map.put("SetId",ContextUtils.getUserId());//操作人编号
                Map<String,Object> worderMap=rdWorderMapper.getWorderByTenIdSetId(map);
                //工单编号
                Map<String,Object>uuid=utilsMapper.getUUID(new HashMap<String,Object>(){{
                    put("uuid", "WoId");
                    put("database", Constants.DATA_SOURCE_TCMKT);
                    put("surface", "tcmkt_worder");
                }});
                System.out.println("uuid:"+uuid);
                if(uuid!=null &&(!uuid.get("uuid").toString().equals(""))){
                    int number=Integer.valueOf(uuid.get("uuid").toString());
                    UUID= ComUtils.getLocalTrmSeqNum("wo",number);
                }else{
                    UUID=ComUtils.getLocalTrmSeqNum("wo",0);
                }
                System.out.println("前端传递的参数:"+params);
                params.put("by", ContextUtils.getUserId());//操作人
                params.put("WoId",UUID);
                params.put("SetId",ContextUtils.getUserId());// 创建工单的人的编号

                params.put("OperId",ContextUtils.getUserId());//接单 操作工单人的编号
                if (vo!=null){
                    params.put("SeId",vo.getDeptId());//接单 操作该工单人的服务中心编号
                }
                params.put("TenStatus",1);//意向租客状态 1工单带看中 2放弃跟踪
                params.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonInsertParms(params);
                params.put("Bind",params.get("instm"));//操作人绑定的时间
                //客户编号
                Map<String,Object> params2=params;
                System.out.println("前端传递的参数:"+params2);
                params2.put("by", ContextUtils.getUserId());//操作人
                params2.put("TenId",map.get("TenId"));
                params2.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params2.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonInsertParms(params2);
                //把客户编号存入工单表中
                params.put("TenId",map.get("TenId"));

                if(map!=null){
                    params.putAll(map);
                    if (params.get("IfSeeing").toString().equals("1")){
                        params.put("State",3);//工单状态 0 需带看 1带看中 2 带看完成 3 租客维护 4 换房申请
                    }else{
                        params.put("State",0);//工单状态 0 需带看 1带看中 2 带看完成 3 租客维护 4 换房申请
                    }
                    System.out.println("转换过后的params:"+params);
                    Integer count=0;
                    if (worderMap==null){
                        params.put("TenName",map.get("MakeUserName"));//租客姓名
                        count=rdWorderMapper.addWorder(params);
                    }else{
                        params.put("WoId",worderMap.get("WoId"));
                    }
                    //新增工单详表
                    Map<String,Object>uuid3=utilsMapper.getUUID(new HashMap<String,Object>(){{
                        put("uuid", "WoInfoId");
                        put("database", Constants.DATA_SOURCE_TCMKT);
                        put("surface", "tcmkt_worder_info");
                    }});
                    System.out.println("uuid:"+uuid3);
                    if(uuid3!=null &&(!uuid3.get("uuid").toString().equals(""))){
                        int number=Integer.valueOf(uuid3.get("uuid").toString());
                        UUID= ComUtils.getLocalTrmSeqNum("wi",number);
                    }else{
                        UUID=ComUtils.getLocalTrmSeqNum("wi",0);
                    }
                    params.put("WoInfoId",UUID);
                    rdWorderInfoMapper.addWorderInfo(params);
                    if (count>0 && tenCount==0){
                        //把工单编号存入到客户表中
                        params2.put("WoId",params.get("WoId"));
                        params2.putAll(map);
                        System.out.println("params2:"+params2);
                        params2.put("ContactTime",params2.get("instm"));//租客的联系时间
                        rdTenantMapper.addTenant(params2);
                    }
                    result.putSuccess("操作成功");
                }else{
                    result.putFailed("服务器繁忙");
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                }
            } catch (Exception e) {
                result.putFailed("服务器繁忙");
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }
    /**
     * 创建工单 在客户池点击
     *
     * 创建工单
     *
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult addWorderTenant(Map<String, Object> params) {
        JsonResult result=new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try{

            try {
                SysUserVo userVo = ContextUtils.getSysUser();
                ParentDeptVo vo = null;
                for (int i = 0; i < userVo.getLength(); i++) {
                    ParentDeptVo vo1 = userVo.getParentDeptVo();
                    if (vo1.getType().equals(3)) {
                        vo = vo1;
                        break;
                    }
                }
                //工单编号
                params.put("SetId",ContextUtils.getUserId());// 创建工单的人的编号
                if (vo!=null){
                    params.put("SeId",ContextUtils.getUserId());//接单 操作工单人的编号
                }
                params.put("by", ContextUtils.getUserId());//操作人的编号
                params.put("term", "2");// 更新端 Update端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                params.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(params);
                params.put("Bind",params.get("updtm"));//租赁顾问跟工单绑定的时间
                Map<String,Object> map=(Map<String,Object>)params.get("data");
                if (map.get("WoId")==null || map.get("TenId")==null){
                    return result.putFailed("参数不正确");
                }
                if(map!=null){
                    //修改工单的主表
                    params.put("WoId",map.get("WoId"));
                    Integer count1=rdWorderMapper.updateWorder(params);
                    //修改客户的状态
                    params.put("SoId",map.get("SoId"));
                    params.put("TenStatus",1);
                    params.put("TenId",map.get("TenId"));
                    Integer count2=rdTenantMapper.updateTenant(params);
                    //新增一条工单详表的记录
                    Map<String,Object> uuid=utilsMapper.getUUID(new HashMap<String,Object>(){{
                        put("uuid", "WoInfoId");
                        put("database", Constants.DATA_SOURCE_TCMKT);
                        put("surface", "tcmkt_worder_info");
                    }});
                    if(uuid!=null){
                        int number=Integer.valueOf(uuid.get("uuid").toString());
                        UUID= ComUtils.getLocalTrmSeqNum("wi",number);
                    }else{
                        UUID=ComUtils.getLocalTrmSeqNum("wi",0);
                    }
                    map.put("OperId",ContextUtils.getUserId());
                    map.put("by",map.get("OperId"));//操作人
                    map.put("MakeUserName",params.get("MakeUserName"));//工单姓名
                    map.put("WoInfoId",UUID);
                    map.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                    map.put("fnc",
                            this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                    ParamsCommon.commonInsertParms(map);
                    Integer count3=rdWorderInfoMapper.addWorderInfo(map);
                    if (count1>0 && count2>0 &&count3>0){
                        result.putSuccess("操作成功");
                    }else{
                        result.putFailed("服务器繁忙");
                    }
                }else{
                    return result.putFailed("服务器繁忙");
                }
            } catch (Exception e) {
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }
    /**
     * 接收转单
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult addWorderOrWorderInfo(Map<String,Object> params){
        JsonResult result=new JsonResult();
        /**
         * 加锁操作
         */
        lock.lock();
        try{
            try {
                SysUserVo userVo = ContextUtils.getSysUser();
                ParentDeptVo vo = null;
                for (int i = 0; i < userVo.getLength(); i++) {
                    ParentDeptVo vo1 = userVo.getParentDeptVo();
                    if (vo1.getType().equals(3)) {
                        vo = vo1;
                        break;
                    }
                }
                //修改工单的转单状态 转单被接单
                Map<String,Object> marketMap=new HashMap<String,Object>();
                marketMap.put("WoInfoId",params.get("WoInfoId"));//工单详表编号
                //工单详表编号
                String WoInfoId="";
                Map<String,Object> uuid2=utilsMapper.getUUID(new HashMap<String,Object>(){{
                    put("uuid", "WoInfoId");
                    put("database", Constants.DATA_SOURCE_TCMKT);
                    put("surface", "tcmkt_worder_info");
                }});
                if(uuid2!=null){
                    int number=Integer.valueOf(uuid2.get("uuid").toString());
                    WoInfoId= ComUtils.getLocalTrmSeqNum("wi",number);
                }else{
                    WoInfoId=ComUtils.getLocalTrmSeqNum("wi",0);
                }
                //转单接收之前先查询这个客户 和接单人是否有
                params.put("SetId",ContextUtils.getUserId());//接单 人编号
                Map<String,Object> tcmkrMap=rdWorderMapper.getWorderByTenIdSetId(params);
                if (tcmkrMap==null){//如果  接单人和租客 没有创建过工单
                    //工单主表编号
                    Map<String,Object> uuid=utilsMapper.getUUID(new HashMap<String,Object>(){{
                        put("uuid", "WoId");
                        put("database", Constants.DATA_SOURCE_TCMKT);
                        put("surface", "tcmkt_worder");
                    }});
                    if(uuid!=null){
                        int number=Integer.valueOf(uuid.get("uuid").toString());
                        UUID= ComUtils.getLocalTrmSeqNum("wo",number);
                    }else{
                        UUID=ComUtils.getLocalTrmSeqNum("wo",0);
                    }
                    params.put("WoId",UUID);//客户编号
                    params.put("SetId",ContextUtils.getUserId());//操作人编号
                    if (vo!=null){
                        params.put("SeId",vo.getDeptId());//接单 操作该工单人的服务中心编号
                    }
                    params.put("by", ContextUtils.getUserId());//操作人编号
                    params.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                    params.put("fnc",
                            this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                    ParamsCommon.commonInsertParms(params);
                    params.put("Bind",params.get("instm"));//操作人绑定工单的时间
                    rdWorderMapper.addWorder(params);//创建工单详表
                    //工单详表编号
                    params.put("WoInfoId",WoInfoId);//工单详表编号
                    params.put("OperId",ContextUtils.getUserId());//接单人编号

                    if (vo!=null){
                        params.put("TurnSeId",vo.getDeptId());//转单服务中心编号
                    }
                    params.put("TurnSysId",userVo.getUserId());//转单伙伴编号
                    params.put("TurnCount","1");//转单次数
                    params.put("TurnJoinTime",params.get("instm"));//转单接单时间
                    params.put("State","3");//工单状态0 需带看 1带看中 2 带看完成 3 租客维护 4 换房申请
                    rdWorderInfoMapper.addWorderInfo(params);
                }else{
                    params.put("WoId",tcmkrMap.get("WoId"));//工单主表编号
                    params.put("WoInfoId",WoInfoId);//工单详表编号
                    params.put("OperId",ContextUtils.getUserId());//接单人编号
                    if (vo!=null){
                        params.put("TurnSeId",vo.getDeptId());//转单服务中心编号
                    }
                    params.put("TurnSysId",userVo.getUserId());//转单伙伴编号
                    params.put("TurnCount","1");//转单次数
                    params.put("TurnJoinTime",params.get("instm"));//转单接单时间
                    params.put("State","3");//工单状态0 需带看 1带看中 2 带看完成 3 租客维护 4 换房申请
                    rdWorderInfoMapper.addWorderInfo(params);
                }
                marketMap.put("TurnStatus","2");//转单状态（0 默认 1转单求助中 2 转单被接单）
                marketMap.put("TurnJoinTime",marketMap.get("updtm"));//转单接单时间
                marketMap.put("by", ContextUtils.getUserId());//操作人编号
                marketMap.put("term", "2");// 创建端 Insert端： 1 租客端 2市场部 3 工程部   4运营部   5财务部  6总经办 7发展部
                marketMap.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonUpdateParms(marketMap);
                Integer count=rdWorderInfoMapper.updateWorderInfo(marketMap);
                if (count>0){
                    result.putSuccess("操作成功");
                }else{
                    result.putFailed("服务器繁忙");
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                }
            } catch (Exception e) {
                result.putFailed("服务器繁忙");
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
        }
        finally {
            lock.unlock();
        }
        return result;
    }
    /**
     * 获取58集中式房源预约信息列表
     */
    public JsonResult api_order_info_get(Map<String,Object> params){
        JsonResult result=new JsonResult();
        //判断分页参数是否为空 limit 分页的每页预约记录个数  page 预约记录分页的第几页
        if (params.get("limit")==null || params.get("page")==null){
            return result.putFailed("参数不正确");
        }
        //组装请求58的获取房源的预约信息参数对象
        Map<String,Object> dataMap=new HashMap<String,Object>();
        //58分配的应用编号
        dataMap.put("appId", InteSameCityConfig.APPID_TEST);
        dataMap.put("limit",params.get("limit"));//分页的每页预约记录个数
        dataMap.put("page",params.get("page"));//预约记录分页的第几页
        //房管姓名筛选条件
        if (params.get("agentNameList")==null){
            List<String> agentNameList=(List<String>)params.get("agentNameList");
            dataMap.put("agentName",agentNameList);
        }
        //筛选一段时间内的预约信息记录列表
        if (params.get("startTime")!=null && params.get("endTime")!=null ){
            //开始时间
            dataMap.put("startTime",params.get("startTime"));
            //结束时间
            dataMap.put("endTime",params.get("endTime"));
        }
        //请求体
        Map<String,String> maphead=new HashMap<String,String>();
        //组装请求接口的map类型参数 转成json 然后生成加密字符串
        String rsaString= ThirdRSACoder.encrypt(JSON.toJSONString(dataMap),InteSameCityConfig.PRIVATE_KEY);
        log.info("rsaString:"+rsaString);
        log.info("rsaString2:"+ThirdRSACoder.decrypt(rsaString,InteSameCityConfig.PUBLIIC_KEY));
        maphead.put("data",rsaString);
        //分页获取房源预约记录列表
        Map<String,Object> sameShellResult= InteSameCityUtil.api_order_info_get(maphead);
        if (sameShellResult.get("code")!=null && sameShellResult.get("code").toString().equals("0")){
            result.put(sameShellResult);
        }else{
            result.putFailed("服务器繁忙");
        }
        return result;
    }
}
